using Ln.Fram.Ddd.Application;
using Ln.Fram.SqlSugarCore.Abstractions;
using Ln.Rbac.Application.Contracts.Dtos.Role;
using Ln.Rbac.Application.Contracts.Dtos.User;
using Ln.Rbac.Application.Contracts.IServices;
using Ln.Rbac.Domain.Entities;
using Ln.Rbac.Domain.Managers;
using Ln.Rbac.Domain.Shared.Consts;
using Ln.Rbac.Domain.Shared.Enums;
using Mapster;
using Microsoft.AspNetCore.Mvc;
using SqlSugar;
using Volo.Abp.Application.Dtos;
using Volo.Abp.Domain.Entities;

namespace Ln.Rbac.Application.Services.System;

/// <summary>
/// Role服务实现
/// </summary>
public class RoleService : LnCrudAppService<RoleAggregateRoot, RoleGetOutputDto, RoleGetListOutputDto, Guid, RoleGetListInputVo, RoleCreateInputVo, RoleUpdateInputVo>, IRoleService
{
	public RoleService(RoleManager roleManager, ISqlSugarRepository<RoleDeptEntity> roleDeptRepository,
			ISqlSugarRepository<UserRoleEntity> userRoleRepository,
			ISqlSugarRepository<RoleAggregateRoot, Guid> repository) : base(repository)
	{
		(_roleManager, _roleDeptRepository, _userRoleRepository, _repository) = (roleManager, roleDeptRepository, userRoleRepository, repository);
	}

	private ISqlSugarRepository<RoleAggregateRoot, Guid> _repository;

	private RoleManager _roleManager { get; set; }

	private ISqlSugarRepository<RoleDeptEntity> _roleDeptRepository;

	private ISqlSugarRepository<UserRoleEntity> _userRoleRepository;

	public async Task UpdateDataScpoceAsync(UpdateDataScpoceInput input)
	{
		//只有自定义的需要特殊处理
		if (input.DataScope == DataScopeEnum.CUSTOM)
		{
			await _roleDeptRepository.DeleteAsync(x => x.RoleId == input.RoleId);
			var insertEntities = input.DeptIds.Select(x => new RoleDeptEntity { DeptId = x, RoleId = input.RoleId }).ToList();
			await _roleDeptRepository.InsertRangeAsync(insertEntities);
		}
		var entity = new RoleAggregateRoot() { DataScope = input.DataScope };
		EntityHelper.TrySetId(entity, () => input.RoleId);
		await _repository._Db.Updateable(entity).UpdateColumns(x => x.DataScope).ExecuteCommandAsync();
	}

	public override async Task<PagedResultDto<RoleGetListOutputDto>> GetListAsync(RoleGetListInputVo input)
	{
		RefAsync<int> total = 0;
		var entities = await _repository._DbQueryable.WhereIF(!string.IsNullOrEmpty(input.RoleCode),
			x => x.RoleCode.Contains(input.RoleCode!))
			.WhereIF(!string.IsNullOrEmpty(input.RoleName), x => x.RoleName.Contains(input.RoleName!))
			.WhereIF(input.State is not null, x => x.State == input.State)
			.ToPageListAsync(input.SkipCount, input.MaxResultCount, total);
		return new PagedResultDto<RoleGetListOutputDto>(total, await MapToGetListOutputDtosAsync(entities));
	}

	/// <summary>
	/// 添加角色
	/// </summary>
	/// <param name="input"></param>
	/// <returns></returns>
	public override async Task<RoleGetOutputDto> CreateAsync(RoleCreateInputVo input)
	{
		var isExist =
				await _repository.IsAnyAsync(x => x.RoleCode == input.RoleCode || x.RoleName == input.RoleName);
		if (isExist)
			throw new UserFriendlyException(RoleConst.Exist);
		var entity = await MapToEntityAsync(input);
		await _repository.InsertAsync(entity);
		var outputDto = await MapToGetOutputDtoAsync(entity);
		return outputDto;
	}

	/// <summary>
	/// 修改角色
	/// </summary>
	/// <param name="id"></param>
	/// <param name="input"></param>
	/// <returns></returns>
	public override async Task<RoleGetOutputDto> UpdateAsync(Guid id, RoleUpdateInputVo input)
	{
		var entity = await _repository.GetByIdAsync(id);
		var isExist = await _repository._DbQueryable.Where(x => x.Id != entity.Id).AnyAsync(x => x.RoleCode == input.RoleCode || x.RoleName == input.RoleName);
		if (isExist)
			throw new UserFriendlyException(RoleConst.Exist);
		await MapToEntityAsync(input, entity);
		await _repository.UpdateAsync(entity);
		await _roleManager.GiveRoleSetMenuAsync(new List<Guid> { id }, input.MenuIds);
		var dto = await MapToGetOutputDtoAsync(entity);
		return dto;
	}

	/// <summary>
	/// 更新状态
	/// </summary>
	/// <param name="id"></param>
	/// <param name="state"></param>
	/// <returns></returns>
	//[Route("role/{id}/{state}")]
	public async Task<RoleGetOutputDto> UpdateStateAsync([FromRoute] Guid id, [FromRoute] bool state)
	{
		var entity = await _repository.GetByIdAsync(id);
		if (entity is null)
			throw new ApplicationException("角色未存在");
		entity.State = state;
		await _repository.UpdateAsync(entity);
		return await MapToGetOutputDtoAsync(entity);
	}

	/// <summary>
	/// 获取角色下的用户
	/// </summary>
	/// <param name="roleId"></param>
	/// <param name="input"></param>
	/// <param name="isAllocated">是否在该角色下</param>
	/// <returns></returns>
	//[Route("role/auth-user/{roleId}/{isAllocated}")]
	public async Task<PagedResultDto<UserGetListOutputDto>> GetAuthUserByRoleIdAsync([FromRoute] Guid roleId, [FromRoute] bool isAllocated, [FromQuery] RoleAuthUserGetListInput input)
	{
		PagedResultDto<UserGetListOutputDto> output;
		//角色下已授权用户
		if (isAllocated == true)
			output = await GetAllocatedAuthUserByRoleIdAsync(roleId, input);
		//角色下未授权用户
		else
			output = await GetNotAllocatedAuthUserByRoleIdAsync(roleId, input);
		return output;
	}

	private async Task<PagedResultDto<UserGetListOutputDto>> GetAllocatedAuthUserByRoleIdAsync(Guid roleId, RoleAuthUserGetListInput input)
	{
		RefAsync<int> total = 0;
		var output = await _userRoleRepository._DbQueryable
			.LeftJoin<UserAggregateRoot>((ur, u) => ur.UserId == u.Id && ur.RoleId == roleId)
			.Where((ur, u) => ur.RoleId == roleId)
			.WhereIF(!string.IsNullOrEmpty(input.UserName), (ur, u) => u.UserName.Contains(input.UserName))
			.WhereIF(input.Phone is not null, (ur, u) => u.Phone.ToString().Contains(input.Phone.ToString()))
			.Select((ur, u) => new UserGetListOutputDto { Id = u.Id }, true)
			.ToPageListAsync(input.SkipCount, input.MaxResultCount, total);
		return new PagedResultDto<UserGetListOutputDto>(total, output);
	}

	private async Task<PagedResultDto<UserGetListOutputDto>> GetNotAllocatedAuthUserByRoleIdAsync(Guid roleId, RoleAuthUserGetListInput input)
	{
		RefAsync<int> total = 0;
		var entities = await _userRoleRepository._Db.Queryable<UserAggregateRoot>()
			.Where(u => SqlFunc.Subqueryable<UserRoleEntity>().Where(x => x.RoleId == roleId)
			.Where(x => x.UserId == u.Id).NotAny())
			.WhereIF(!string.IsNullOrEmpty(input.UserName), u => u.UserName.Contains(input.UserName))
			.WhereIF(input.Phone is not null, u => u.Phone.ToString().Contains(input.Phone.ToString()))
			.ToPageListAsync(input.SkipCount, input.MaxResultCount, total);
		var output = entities.Adapt<List<UserGetListOutputDto>>();
		return new PagedResultDto<UserGetListOutputDto>(total, output);
	}

	/// <summary>
	/// 批量给用户授权
	/// </summary>
	/// <param name="input"></param>
	/// <returns></returns>
	public async Task CreateAuthUserAsync([FromBody] RoleAuthUserCreateOrDeleteInput input)
	{
		var userRoleEntities = input.UserIds.Select(u => new UserRoleEntity { RoleId = input.RoleId, UserId = u }).ToList();
		await _userRoleRepository.InsertRangeAsync(userRoleEntities);
	}

	/// <summary>
	/// 批量取消授权
	/// </summary>
	/// <param name="input"></param>
	/// <returns></returns>
	public async Task DeleteAuthUserAsync([FromBody] RoleAuthUserCreateOrDeleteInput input)
	{
		await _userRoleRepository._Db.Deleteable<UserRoleEntity>().Where(x => x.RoleId == input.RoleId)
			.Where(x => input.UserIds.Contains(x.UserId))
			.ExecuteCommandAsync();
	}
}